home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’96 / Talking Telnet / source / printing / printing.c next >
Text File  |  1996-06-22  |  13KB  |  420 lines
  1. /*
  2. *    printing.c
  3. *
  4. *    This now contains the PrintPages() code from Roland Mansson, from Lund 
  5. *    University Computing Center.  This allows for printer redirection, and also
  6. *    printing page numbers (and other goodies).  Thanks for all of your work!
  7. *
  8. *
  9. *
  10. *****************************************************************
  11. *    NCSA Telnet for the Macintosh                                *
  12. *                                                                *
  13. *    National Center for Supercomputing Applications                *
  14. *    Software Development Group                                    *
  15. *    152 Computing Applications Building                            *
  16. *    605 E. Springfield Ave.                                        *
  17. *    Champaign, IL  61820                                        *
  18. *                                                                *
  19. *    Copyright (c) 1986-1992,                                    *
  20. *    Board of Trustees of the University of Illinois                *
  21. *****************************************************************
  22. *    Code to handle printing.
  23. */
  24.  
  25. #ifdef MPW
  26. #pragma segment Printing
  27. #endif
  28.  
  29.  
  30. #include "wind.h"
  31. #include "rsinterf.proto.h"    /* For RSGetSelText */
  32. #include "netevent.proto.h"
  33. #include "vgtek.proto.h"
  34. #include "rgmp.proto.h"
  35. #include "event.proto.h"
  36. #include "tekrgmac.proto.h"
  37.  
  38.  
  39.  
  40. #include "vsdata.h"
  41. #include "vsinterf.proto.h"
  42.  
  43. extern Cursor *theCursors[];
  44. extern WindRec
  45.     *screens;            /* The screen array from Maclook */
  46. extern short scrn;
  47.  
  48. PROTO_UPP(printsleep, PrIdle);
  49. extern    void printsleep(void);
  50.  
  51. THPrint    gPrRecHandle = NULL;
  52.  
  53. #define PGRECT    (*PrRecHandle)->prInfo.rPage        /* Macro for making the pagerect more accessible */
  54. #define VMARGINS 4
  55. #define PAPRECT (*PrRecHandle)->rPaper /* Macro for making the paperrect more accessible */
  56. #define bDevCItoh 1 /* from Printing.h */
  57. #define ascLF 10
  58. #define ascFF 12
  59. #define ascCR 13
  60.  
  61. #include "printing.proto.h"
  62.  
  63. void    PrintingUnload(void) {}
  64.  
  65. /*    userabort - check to see if the user wants to abort */
  66. short userabort(void)
  67. {
  68.     EventRecord theEvent;
  69.  
  70.     while (GetNextEvent(24,&theEvent)) {
  71.         if ((theEvent.modifiers & cmdKey) &&
  72.             (theEvent.message & 0xff) =='.') 
  73.             return(-1);
  74.         }
  75.     return(0);
  76. }
  77.  
  78. /*    printsleep()    - Provide the network keep alive while we are in print
  79.  *                      mode.  Also set the abort flag if necessary. */
  80. SIMPLE_UPP(printsleep, PrIdle);
  81. void printsleep(void)
  82. {
  83.     short    CurrentResFile;
  84.     
  85.     CurrentResFile = CurResFile();        /* Save the current resource file just in case. */
  86.     Stask();                            /* act like the postman */
  87.     if (userabort())
  88.         (*gPrRecHandle)->prJob.fFromUsr=TRUE;
  89.     UseResFile(CurrentResFile);            /* Restore this in case we were bad and changed it. */
  90. }
  91.  
  92. /*    printGraph -    Print the graphics on the current window
  93.  *        vg - which graphics window to print */
  94.  
  95. void printGraph(short dnum)            /* Which drawing to print */
  96. {
  97.     short h,v;            /* used for centering (h=horiz. , v=vert.) */
  98.     short wh,wv;            /* Window horiz and vert */
  99.     TPrStatus
  100.         prStatus;        /* Printing status record */
  101.     Rect prRect;        /* the rectangle to print in */
  102.     TPPrPort prPort;    /* the printing port */
  103.     short j;                /* VG identifier for pass-through */
  104.     THPrint        PrRecHandle;    /* our print record handle */
  105.  
  106.     PrRecHandle = PrintSetupRecord();
  107.         
  108.     SetCursor(theCursors[normcurs]);
  109.  
  110.     if (PrJobDialog(PrRecHandle)) {            /* Cancel the print if FALSE */
  111.         prPort=PrOpenDoc(PrRecHandle,0L,0L);        /* Open Printer Port */
  112.             if (PrError() == 0)    {                /* If we can't, then die */
  113.                 PrOpenPage(prPort, 0L);                /* Open a page */
  114.  
  115.                 (*PrRecHandle)->prJob.pIdleProc = printsleepUPP;    /* our sleep/cancel*/
  116.  
  117.                 prRect=PGRECT;                        /* Get the page rectangle */
  118.                 h=prRect.right - prRect.left;    /* Get the width */
  119.                 v=prRect.bottom- prRect.top;    /* Get the height */
  120.                 if (3*h<4*v) {                    /* Center the little bugger */
  121.                     wh = h;
  122.                     wv = (3 * h)/ 4;
  123.                     }
  124.                 else {                            /* On the page rectangle */
  125.                     wv = v;
  126.                     wh = (4 * v)/ 3;
  127.                     }
  128.         
  129.                 prRect.top  = (v- wv) /2;
  130.                 prRect.left = (h- wh) /2;
  131.                 prRect.bottom = prRect.top + wv;
  132.                 prRect.right = prRect.left + wh;
  133.  
  134.                 j=VGnewwin(TEK_DEVICE_PICTURE,VGgetVS(dnum));        /* NCSA 2.5: fixed the print call */
  135.                 RGMPsize( &prRect );
  136.                 VGzcpy( dnum, j);                /* Love dat zm factr */
  137.                 VGredraw(dnum,j);                /* Copy the picture in i to j */
  138.                 VGclose(j);                        /* OK, we're done, give it to someone else */
  139.                 PrClosePage(prPort);            /* Page out.... */
  140.                 }
  141.  
  142.             PrCloseDoc(prPort);                    /* Done with the document */
  143.             putln("Doc is closed... the printing begins....");
  144.  
  145.         if (PrError()==0)                                                    /* BYU 2.4.20 - changed for HP DeskWriter*/
  146.             PrPicFile(PrRecHandle,0L,0L,0L,&prStatus);
  147.                                     /* Print the spooled file if applicable */
  148.     }        /* if PrJobDialog */
  149.     
  150.     DisposeHandle((Handle)PrRecHandle);
  151.     updateCursor(1);
  152. }
  153.  
  154.  
  155.  
  156.  
  157.  
  158. /* LU - this is the NEW PrintPages code.  This handles page numbering, and also
  159.         allows us to dump the redirected output to the printer.  Written by
  160.         Roland Mansson, Lund University Computing Center.  Thank HIM for this code... */
  161. /* Some patches had to be made to get it to compile under THINK C, and to work        */
  162. /* with some of the changes we have recently made.   - SMB                            */
  163.  
  164.  
  165.  
  166.  
  167. /*    printPages(prPort,charh,title, columns) -
  168.  *            Prints <charh> on the printer through port <prPort> with <title>
  169.  *            using <columns>.
  170.  */
  171. void printPages(TPPrPort prPort, THPrint PrRecHandle, Str255 Title, short columns, char **charh, short refNum, short useTitle, short theScreen)
  172. {
  173.     char    *charp, *start;
  174.     long    charlen,count=0L;
  175.     short        v, h, scount, lines, pgcount, pgtmplen, maxlines;
  176.     char    pagetemp[20];
  177.     FMetricRec info;
  178.     short        pFheight, pFwidth;
  179.     unsigned char buf[256];        /* to build a line in from the file */
  180.     unsigned char nextchar;        /* next unprocessed char in file */
  181.     short        rdy;
  182.     short    indent;                /* indent to give reasonable left marginal */
  183.     OSErr    sts;
  184.     long    dummyCount;
  185.     char    tmp[100];            /* only for debugging */
  186.     char    stupidarray[160];    /* used in menuseg for finding string widths */
  187.  
  188.     for (v=0; v<150; v++) stupidarray[v]='W';    /* Set up the width array */
  189.  
  190.     indent = ((*PrRecHandle)->prInfo.iHRes * 180)/254;    /* 1.8 centimeters left margin */
  191.     if (-PAPRECT.left > indent)
  192.         indent = 0;
  193.     else
  194.         indent += PAPRECT.left;
  195.  
  196.     if ( ((*PrRecHandle)->prStl.wDev>>8) == bDevCItoh ) {
  197.                     /* Think about this: put def. font in rsrc fork- STR255 */
  198.         TextFont(monaco);            /* gives monaco on ImageWriters … */
  199.         v=9;
  200.         }
  201.     else {                            /* NCSA: SB - use current font */
  202.         TextFont((*(screens[theScreen].wind)).txFont);        /* NCSA: SB */
  203.         TextFace((*(screens[theScreen].wind)).txFace);        /* NCSA: SB */
  204.         v = (*(screens[theScreen].wind)).txSize;            /* NCSA: SB */
  205.         }                                                    /* NCSA: SB */
  206.     
  207.     do {
  208.         TextSize(v);
  209.         FontMetrics( &info );
  210.         pFheight = FixRound( info.ascent + info.descent + info.leading);
  211.         pFwidth  = FixRound( info.widMax);
  212.         //pFwidth  = CharWidth('W');            /* Re-assign to largest char */
  213.         v--;
  214.     } while ( TextWidth(stupidarray,0,columns+1) > (PGRECT.right - PGRECT.left - indent));
  215.     sprintf (tmp,"Fheight:%d, Fwidth:%d, TextSize:%d",pFheight,pFwidth,v+1); putln (tmp);
  216.  
  217.     if (charh!=NULL) {
  218.         HLock(charh);
  219.         start=charp=*charh;
  220.         charlen= GetHandleSize(charh);
  221.     } else {
  222.         if ((sts=GetFPos(refNum, &charlen)) != noErr)
  223.             {
  224.             sprintf(tmp,"GetFPos: ERROR %d",(short)sts);
  225.             putln(tmp);
  226.             }
  227.         charlen-=3;                    /* skip last 3 chars, as they are part of ESC seq */
  228.         if ((sts=SetFPos(refNum,(short) fsFromStart,0L)) != noErr)    /* rewind to beginning of file */
  229.             { sprintf(tmp,"SetFPos: ERROR %d",sts); putln(tmp); }
  230.         start = (char *)buf;                /* always (the array doesn't move) */
  231.         dummyCount=1;
  232.         if ((sts=FSRead(refNum,&dummyCount,&nextchar)) != noErr)        /* get first char */
  233.             { sprintf(tmp,"FSRead: ERROR %d",sts); putln(tmp); }
  234.     }
  235.     
  236.     h=PGRECT.right - PGRECT.left - indent;    /* Get the width */
  237.     v=PGRECT.bottom- PGRECT.top;            /* Get the height */
  238.  
  239.     maxlines = v/pFheight-1;
  240.     pgcount = 0;
  241.     while (count<charlen) {
  242.         pgcount++;
  243.         lines = 1;
  244.         PrOpenPage(prPort, 0L);        /* Open the Printer Page */
  245.         if ((sts=PrError()) != noErr) { sprintf(tmp,"PrOpenPage: ERROR %d",sts); putln(tmp); }
  246.         (*PrRecHandle)->prJob.pIdleProc= printsleepUPP;            /* our netsleep */
  247.         sprintf (tmp,"printing page:%d",pgcount); putln(tmp);
  248.  
  249.         if (useTitle) {
  250.             Str255 SessionNameString;
  251.             GetIndString(SessionNameString,MISC_STRINGS,SESSION_NAME_STRING);
  252.             MoveTo( indent, lines*pFheight);
  253.             DrawString(SessionNameString);            /* BYU LSC */
  254.     
  255.             DrawString( Title);            /* BYU LSC */
  256.             sprintf(pagetemp, "Page %d", pgcount);
  257.             pgtmplen=strlen(pagetemp);
  258.             MoveTo( PGRECT.right-(pgtmplen * pFwidth)-1, lines++*pFheight);
  259.             DrawText( pagetemp, 0, pgtmplen);
  260.             lines++;                    /* one blank line after title line */
  261.         }
  262.  
  263.         if (charh!=NULL) {                                    /* print from handle */
  264.             while (lines <= maxlines && count<charlen) {
  265.                 scount=0;
  266.                 while ((count<charlen) && (*charp++!='\r')) { count++; scount++; }
  267.                 MoveTo(indent,lines++*pFheight);
  268.                 if (scount>0)
  269.                     DrawText(start, 0, scount);
  270.                 count++;
  271.                 start=charp;
  272.             }
  273.         } else {                                            /* print from file */
  274.             while (lines <= maxlines && count<charlen) {
  275.                 rdy = 0;
  276.                 scount = 0;
  277.                 while ((count<charlen) && (!rdy)) {
  278.                     switch (nextchar) {
  279.                         case ascCR:
  280.                             rdy=1;
  281.                             break;
  282.                         case ascLF:
  283.                             rdy=1;
  284.                             break;
  285.                         case ascFF:
  286.                             rdy=1;
  287.                             break;
  288.                         default:
  289.                             buf[scount++]=nextchar;
  290.                             count++;
  291.                             dummyCount=1;
  292.                             if ((sts=FSRead (refNum,&dummyCount,&nextchar)) != noErr)
  293.                                 { sprintf(tmp,"FSRead: ERROR %d",sts); putln(tmp); }
  294.                             break;
  295.                     }
  296.                 }
  297.                 MoveTo(indent,lines*pFheight);
  298.                 if (scount>0)
  299.                     DrawText(start, 0, scount);
  300.                 if (nextchar==ascLF)
  301.                     lines++;                        /* LF -> new line */
  302.                 if (nextchar==ascFF)
  303.                     lines = maxlines+1;                /* FF -> new page */
  304.                 dummyCount=1;
  305.                 if ((sts=FSRead (refNum,&dummyCount,&nextchar)) != noErr)
  306.                     { sprintf(tmp,"FSRead: ERROR %d",sts); putln(tmp); }
  307.                 count++;
  308.             }
  309.         }
  310.         PrClosePage(prPort);        /* Close the Printer page */
  311.         if ((sts=PrError()) != noErr) { sprintf(tmp,"PrClosePage: ERROR %d",sts); putln(tmp); }
  312.     }
  313.     if (charh!=NULL)
  314.         HUnlock(charh);
  315. }
  316.  
  317.  
  318.  
  319. /*    printText -    Print the text selected on the screen 
  320.  *        vs - which vs to print from */
  321. void printText
  322.   (
  323.     short vs,                /* Which screen to print */
  324.     Str255 Title,        /* The title string */
  325.       short scrn
  326.   )
  327. {
  328.     char        **charh;        /* The character handle */
  329.     TPrStatus    prStatus;        /* Status record */
  330.     TPPrPort    prPort;            /* the Printer port */
  331.     THPrint        PrRecHandle;    /* our print record handle */
  332.  
  333.  
  334.     charh = RSGetTextSel(vs,0);                /* Get the characters to print */
  335.  
  336.     if ( charh==0L)
  337.         return;                                /* don't print anything.... */
  338.  
  339.     PrRecHandle = PrintSetupRecord();
  340.  
  341.     SetCursor(theCursors[normcurs]);
  342.     
  343.     if (PrJobDialog(PrRecHandle)) {            /* Cancel the print if FALSE */
  344.         prPort=PrOpenDoc(PrRecHandle,0L,0L);
  345.             if (PrError() == 0)    {
  346.                 printPages( prPort, PrRecHandle, Title, VSmaxwidth(vs), charh, (short) -1, TRUE,scrn);
  347.                 }
  348.             PrCloseDoc(prPort);
  349.  
  350.         if (((*PrRecHandle)->prJob.bJDocLoop == bSpoolLoop) && (PrError()==0))
  351.             PrPicFile(PrRecHandle,0L,0L,0L,&prStatus); /* Spool the print */
  352.         }
  353.     HPurge(charh);                            /* Kill the printed chars */
  354.     updateCursor(1);
  355.     DisposeHandle((Handle)PrRecHandle);
  356. }
  357.  
  358. void PrintPageSetup(void)
  359. {
  360.     THPrint        PrRecHandle;    /* our print record handle */
  361.     
  362.     PrOpen();
  363.  
  364.     PrRecHandle = (THPrint)GetResource('JOHN',169);                    /* AISD: JSA */
  365.     if ( PrRecHandle != NULL ) {                            /* AISD: JSA */
  366.         PrStlDialog(PrRecHandle);                    /* AISD: JSA */
  367.         ChangedResource((Handle)PrRecHandle);        /* AISD: JSA */
  368.         UpdateResFile(TelInfo->SettingsFile);        /* AISD: JSA */
  369.         }                                            /* AISD: JSA */
  370.     else {                                            /* AISD: JSA */
  371.         PrRecHandle=(THPrint)myNewHandle((long)sizeof(TPrint));    /* AISD: JSA */
  372.         PrintDefault(PrRecHandle);                    /* AISD: JSA */
  373.         PrStlDialog(PrRecHandle);                    /* AISD: JSA */
  374.         UseResFile(TelInfo->SettingsFile);            /* AISD: JSA */
  375.         AddResource((Handle)PrRecHandle,'JOHN',169,"\p");    /* AISD: JSA */
  376.         UpdateResFile(TelInfo->SettingsFile);        /* AISD: JSA */
  377.         }                                            /* AISD: JSA */
  378.  
  379.     ReleaseResource((Handle)PrRecHandle);        /* AISD: JSA */
  380.     PrClose();
  381. }
  382.  
  383. void PrintSelection(void)
  384. {
  385.         short    i;
  386.  
  387.         PrOpen();
  388.             
  389.         i=RGgetdnum(FrontWindow());
  390.         if (i>-1)         
  391.             printGraph( i);                        /* Print Graphics */
  392.         else 
  393.             if ( (i=RSfindvwind(FrontWindow())) >-1 ) {
  394.                 Str255 Title;
  395.  
  396.                 GetWTitle( FrontWindow(), Title);
  397.                 printText(i, Title,scrn);    /* Print Text selection */
  398.                 }
  399.         PrClose();
  400. }
  401.  
  402. THPrint PrintSetupRecord(void)
  403. {
  404.     THPrint    PrRecHandle;
  405.     
  406.     PrRecHandle = (THPrint)GetResource('JOHN',169);                    /* AISD: JSA */
  407.  
  408.     if ( PrRecHandle != NULL ) {
  409.         PrValidate(PrRecHandle);
  410.         DetachResource((Handle)PrRecHandle);
  411.         }
  412.     else {
  413.         PrRecHandle=(THPrint)myNewHandle((long)sizeof(TPrint));
  414.         PrintDefault(PrRecHandle);
  415.         }
  416.         
  417.     gPrRecHandle = PrRecHandle;
  418.     return (PrRecHandle);
  419. }
  420.